home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / winsvc.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1998-02-09  |  25.7 KB  |  616 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Run-time Library                         }
  5. {       Windows 32bit API Interface Unit                }
  6. {                                                       }
  7. {       Copyright (c) 1996,98 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit WinSvc;
  12.  
  13. {$ALIGN ON}
  14. {$MINENUMSIZE 4}
  15. {$WEAKPACKAGEUNIT}
  16.  
  17. interface
  18.  
  19. uses Windows;
  20.  
  21. //
  22. // Constants
  23. //
  24.  
  25. const
  26.  
  27. //
  28. // Service database names
  29. //
  30.   {$EXTERNALSYM SERVICES_ACTIVE_DATABASEA}
  31.   SERVICES_ACTIVE_DATABASEA     = 'ServicesActive';
  32.   {$EXTERNALSYM SERVICES_ACTIVE_DATABASEW}
  33.   SERVICES_ACTIVE_DATABASEW     = 'ServicesActive';
  34.   {$EXTERNALSYM SERVICES_ACTIVE_DATABASE}
  35.   SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA;
  36.   {$EXTERNALSYM SERVICES_FAILED_DATABASEA}
  37.   SERVICES_FAILED_DATABASEA     = 'ServicesFailed';
  38.   {$EXTERNALSYM SERVICES_FAILED_DATABASEW}
  39.   SERVICES_FAILED_DATABASEW     = 'ServicesFailed';
  40.   {$EXTERNALSYM SERVICES_FAILED_DATABASE}
  41.   SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA;
  42.  
  43. //
  44. // Character to designate that a name is a group
  45. //
  46.   {$EXTERNALSYM SC_GROUP_IDENTIFIERA}
  47.   SC_GROUP_IDENTIFIERA          = '+';
  48.   {$EXTERNALSYM SC_GROUP_IDENTIFIERW}
  49.   SC_GROUP_IDENTIFIERW          = '+';
  50.   {$EXTERNALSYM SC_GROUP_IDENTIFIER}
  51.   SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA;
  52.  
  53. //
  54. // Value to indicate no change to an optional parameter
  55. //
  56.   {$EXTERNALSYM SERVICE_NO_CHANGE}
  57.   SERVICE_NO_CHANGE              = $FFFFFFFF;
  58.  
  59. //
  60. // Service State -- for Enum Requests (Bit Mask)
  61. //
  62.   {$EXTERNALSYM SERVICE_ACTIVE}
  63.   SERVICE_ACTIVE                 = $00000001;
  64.   {$EXTERNALSYM SERVICE_INACTIVE}
  65.   SERVICE_INACTIVE               = $00000002;
  66.   {$EXTERNALSYM SERVICE_STATE_ALL}
  67.   SERVICE_STATE_ALL              = (SERVICE_ACTIVE   or
  68.                                     SERVICE_INACTIVE);
  69.  
  70. //
  71. // Controls
  72. //
  73.   {$EXTERNALSYM SERVICE_CONTROL_STOP}
  74.   SERVICE_CONTROL_STOP           = $00000001;
  75.   {$EXTERNALSYM SERVICE_CONTROL_PAUSE}
  76.   SERVICE_CONTROL_PAUSE          = $00000002;
  77.   {$EXTERNALSYM SERVICE_CONTROL_CONTINUE}
  78.   SERVICE_CONTROL_CONTINUE       = $00000003;
  79.   {$EXTERNALSYM SERVICE_CONTROL_INTERROGATE}
  80.   SERVICE_CONTROL_INTERROGATE    = $00000004;
  81.   {$EXTERNALSYM SERVICE_CONTROL_SHUTDOWN}
  82.   SERVICE_CONTROL_SHUTDOWN       = $00000005;
  83.  
  84. //
  85. // Service State -- for CurrentState
  86. //
  87.   {$EXTERNALSYM SERVICE_STOPPED}
  88.   SERVICE_STOPPED                = $00000001;
  89.   {$EXTERNALSYM SERVICE_START_PENDING}
  90.   SERVICE_START_PENDING          = $00000002;
  91.   {$EXTERNALSYM SERVICE_STOP_PENDING}
  92.   SERVICE_STOP_PENDING           = $00000003;
  93.   {$EXTERNALSYM SERVICE_RUNNING}
  94.   SERVICE_RUNNING                = $00000004;
  95.   {$EXTERNALSYM SERVICE_CONTINUE_PENDING}
  96.   SERVICE_CONTINUE_PENDING       = $00000005;
  97.   {$EXTERNALSYM SERVICE_PAUSE_PENDING}
  98.   SERVICE_PAUSE_PENDING          = $00000006;
  99.   {$EXTERNALSYM SERVICE_PAUSED}
  100.   SERVICE_PAUSED                 = $00000007;
  101.  
  102. //
  103. // Controls Accepted  (Bit Mask)
  104. //
  105.   {$EXTERNALSYM SERVICE_ACCEPT_STOP}
  106.   SERVICE_ACCEPT_STOP            = $00000001;
  107.   {$EXTERNALSYM SERVICE_ACCEPT_PAUSE_CONTINUE}
  108.   SERVICE_ACCEPT_PAUSE_CONTINUE  = $00000002;
  109.   {$EXTERNALSYM SERVICE_ACCEPT_SHUTDOWN}
  110.   SERVICE_ACCEPT_SHUTDOWN        = $00000004;
  111.  
  112. //
  113. // Service Control Manager object specific access types
  114. //
  115.   {$EXTERNALSYM SC_MANAGER_CONNECT}
  116.   SC_MANAGER_CONNECT             = $0001;
  117.   {$EXTERNALSYM SC_MANAGER_CREATE_SERVICE}
  118.   SC_MANAGER_CREATE_SERVICE      = $0002;
  119.   {$EXTERNALSYM SC_MANAGER_ENUMERATE_SERVICE}
  120.   SC_MANAGER_ENUMERATE_SERVICE   = $0004;
  121.   {$EXTERNALSYM SC_MANAGER_LOCK}
  122.   SC_MANAGER_LOCK                = $0008;
  123.   {$EXTERNALSYM SC_MANAGER_QUERY_LOCK_STATUS}
  124.   SC_MANAGER_QUERY_LOCK_STATUS   = $0010;
  125.   {$EXTERNALSYM SC_MANAGER_MODIFY_BOOT_CONFIG}
  126.   SC_MANAGER_MODIFY_BOOT_CONFIG  = $0020;
  127.  
  128.   {$EXTERNALSYM SC_MANAGER_ALL_ACCESS}
  129.   SC_MANAGER_ALL_ACCESS          = (STANDARD_RIGHTS_REQUIRED or
  130.                                     SC_MANAGER_CONNECT or
  131.                                     SC_MANAGER_CREATE_SERVICE or
  132.                                     SC_MANAGER_ENUMERATE_SERVICE or
  133.                                     SC_MANAGER_LOCK or
  134.                                     SC_MANAGER_QUERY_LOCK_STATUS or
  135.                                     SC_MANAGER_MODIFY_BOOT_CONFIG);
  136.  
  137. //
  138. // Service object specific access type
  139. //
  140.   {$EXTERNALSYM SERVICE_QUERY_CONFIG}
  141.   SERVICE_QUERY_CONFIG           = $0001;
  142.   {$EXTERNALSYM SERVICE_CHANGE_CONFIG}
  143.   SERVICE_CHANGE_CONFIG          = $0002;
  144.   {$EXTERNALSYM SERVICE_QUERY_STATUS}
  145.   SERVICE_QUERY_STATUS           = $0004;
  146.   {$EXTERNALSYM SERVICE_ENUMERATE_DEPENDENTS}
  147.   SERVICE_ENUMERATE_DEPENDENTS   = $0008;
  148.   {$EXTERNALSYM SERVICE_START}
  149.   SERVICE_START                  = $0010;
  150.   {$EXTERNALSYM SERVICE_STOP}
  151.   SERVICE_STOP                   = $0020;
  152.   {$EXTERNALSYM SERVICE_PAUSE_CONTINUE}
  153.   SERVICE_PAUSE_CONTINUE         = $0040;
  154.   {$EXTERNALSYM SERVICE_INTERROGATE}
  155.   SERVICE_INTERROGATE            = $0080;
  156.   {$EXTERNALSYM SERVICE_USER_DEFINED_CONTROL}
  157.   SERVICE_USER_DEFINED_CONTROL   = $0100;
  158.  
  159.   {$EXTERNALSYM SERVICE_ALL_ACCESS}
  160.   SERVICE_ALL_ACCESS             = (STANDARD_RIGHTS_REQUIRED or
  161.                                     SERVICE_QUERY_CONFIG or
  162.                                     SERVICE_CHANGE_CONFIG or
  163.                                     SERVICE_QUERY_STATUS or
  164.                                     SERVICE_ENUMERATE_DEPENDENTS or
  165.                                     SERVICE_START or
  166.                                     SERVICE_STOP or
  167.                                     SERVICE_PAUSE_CONTINUE or
  168.                                     SERVICE_INTERROGATE or
  169.                                     SERVICE_USER_DEFINED_CONTROL);
  170.  
  171.  
  172. type
  173.  
  174. //
  175. // Handle Types
  176. //
  177.  
  178.   {$EXTERNALSYM SC_HANDLE}
  179.   SC_HANDLE = THandle;
  180.   {$EXTERNALSYM LPSC_HANDLE}
  181.   LPSC_HANDLE = ^SC_HANDLE;
  182.  
  183.   {$EXTERNALSYM SERVICE_STATUS_HANDLE}
  184.   SERVICE_STATUS_HANDLE = DWORD;
  185.  
  186. //
  187. // pointer to string pointer
  188. //
  189.  
  190.   {$EXTERNALSYM PLPSTRA}
  191.   PLPSTRA = ^PAnsiChar;
  192.   {$EXTERNALSYM PLPSTRW}
  193.   PLPSTRW = ^PWideChar;
  194.   {$EXTERNALSYM PLPSTR}
  195.   PLPSTR = PLPSTRA;
  196.  
  197. //
  198. // Service Status Structure
  199. //
  200.  
  201.   PServiceStatus = ^TServiceStatus;
  202.   {$EXTERNALSYM _SERVICE_STATUS}
  203.   _SERVICE_STATUS = record
  204.     dwServiceType: DWORD;
  205.     dwCurrentState: DWORD;
  206.     dwControlsAccepted: DWORD;
  207.     dwWin32ExitCode: DWORD;
  208.     dwServiceSpecificExitCode: DWORD;
  209.     dwCheckPoint: DWORD;
  210.     dwWaitHint: DWORD;
  211.   end;
  212.   {$EXTERNALSYM SERVICE_STATUS}
  213.   SERVICE_STATUS = _SERVICE_STATUS;
  214.   TServiceStatus = _SERVICE_STATUS;
  215.  
  216. //
  217. // Service Status Enumeration Structure
  218. //
  219.   PEnumServiceStatusA = ^TEnumServiceStatusA;
  220.   PEnumServiceStatusW = ^TEnumServiceStatusW;
  221.   PEnumServiceStatus = PEnumServiceStatusA;
  222.   {$EXTERNALSYM _ENUM_SERVICE_STATUSA}
  223.   _ENUM_SERVICE_STATUSA = record
  224.     lpServiceName: PAnsiChar;
  225.     lpDisplayName: PAnsiChar;
  226.     ServiceStatus: TServiceStatus;
  227.   end;
  228. {#BEGIN}
  229.   {$EXTERNALSYM ENUM_SERVICE_STATUSA}
  230.   ENUM_SERVICE_STATUSA = _ENUM_SERVICE_STATUSA;
  231.   {$EXTERNALSYM _ENUM_SERVICE_STATUSW}
  232.   _ENUM_SERVICE_STATUSW = record
  233.     lpServiceName: PWideChar;
  234.     lpDisplayName: PWideChar;
  235.     ServiceStatus: TServiceStatus;
  236.   end;
  237. {#BEGIN}
  238.   {$EXTERNALSYM ENUM_SERVICE_STATUSW}
  239.   ENUM_SERVICE_STATUSW = _ENUM_SERVICE_STATUSW;
  240.   {$EXTERNALSYM _ENUM_SERVICE_STATUS}
  241.   _ENUM_SERVICE_STATUS = _ENUM_SERVICE_STATUSA;
  242.   TEnumServiceStatusA = _ENUM_SERVICE_STATUSA;
  243.   TEnumServiceStatusW = _ENUM_SERVICE_STATUSW;
  244.   TEnumServiceStatus = TEnumServiceStatusA;
  245.  
  246. //
  247. // Structures for the Lock API functions
  248. //
  249.   SC_LOCK = Pointer;
  250.   PQueryServiceLockStatusA = ^TQueryServiceLockStatusA;
  251.   PQueryServiceLockStatusW = ^TQueryServiceLockStatusW;
  252.   PQueryServiceLockStatus = PQueryServiceLockStatusA;
  253.   {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSA}
  254.   _QUERY_SERVICE_LOCK_STATUSA = record
  255.     fIsLocked: DWORD;
  256.     lpLockOwner: PAnsiChar;
  257.     dwLockDuration: DWORD;
  258.   end;
  259.   {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSW}
  260.   _QUERY_SERVICE_LOCK_STATUSW = record
  261.     fIsLocked: DWORD;
  262.     lpLockOwner: PWideChar;
  263.     dwLockDuration: DWORD;
  264.   end;
  265.   {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUS}
  266.   _QUERY_SERVICE_LOCK_STATUS = _QUERY_SERVICE_LOCK_STATUSA;
  267.   {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSA}
  268.   QUERY_SERVICE_LOCK_STATUSA = _QUERY_SERVICE_LOCK_STATUSA;
  269.   {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSW}
  270.   QUERY_SERVICE_LOCK_STATUSW = _QUERY_SERVICE_LOCK_STATUSW;
  271.   {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUS}
  272.   QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSA;
  273.   TQueryServiceLockStatusA = _QUERY_SERVICE_LOCK_STATUSA;
  274.   TQueryServiceLockStatusW = _QUERY_SERVICE_LOCK_STATUSW;
  275.   TQueryServiceLockStatus = TQueryServiceLockStatusA;
  276.  
  277. //
  278. // Query Service Configuration Structure
  279. //
  280.   PQueryServiceConfigA = ^TQueryServiceConfigA;
  281.   PQueryServiceConfigW = ^TQueryServiceConfigW;
  282.   PQueryServiceConfig = PQueryServiceConfigA;
  283.   {$EXTERNALSYM _QUERY_SERVICE_CONFIGA}
  284.    _QUERY_SERVICE_CONFIGA = record
  285.     dwServiceType: DWORD;
  286.     dwStartType: DWORD;
  287.     dwErrorControl: DWORD;
  288.     lpBinaryPathName: PAnsiChar;
  289.     lpLoadOrderGroup: PAnsiChar;
  290.     dwTagId: DWORD;
  291.     lpDependencies: PAnsiChar;
  292.     lpServiceStartName: PAnsiChar;
  293.     lpDisplayName: PAnsiChar;
  294.   end;
  295.   {$EXTERNALSYM _QUERY_SERVICE_CONFIGW}
  296.    _QUERY_SERVICE_CONFIGW = record
  297.     dwServiceType: DWORD;
  298.     dwStartType: DWORD;
  299.     dwErrorControl: DWORD;
  300.     lpBinaryPathName: PWideChar;
  301.     lpLoadOrderGroup: PWideChar;
  302.     dwTagId: DWORD;
  303.     lpDependencies: PWideChar;
  304.     lpServiceStartName: PWideChar;
  305.     lpDisplayName: PWideChar;
  306.   end;
  307.   {$EXTERNALSYM _QUERY_SERVICE_CONFIG}
  308.   _QUERY_SERVICE_CONFIG = _QUERY_SERVICE_CONFIGA;
  309.   {$EXTERNALSYM QUERY_SERVICE_CONFIGA}
  310.   QUERY_SERVICE_CONFIGA = _QUERY_SERVICE_CONFIGA;
  311.   {$EXTERNALSYM QUERY_SERVICE_CONFIGW}
  312.   QUERY_SERVICE_CONFIGW = _QUERY_SERVICE_CONFIGW;
  313.   {$EXTERNALSYM QUERY_SERVICE_CONFIG}
  314.   QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGA;
  315.   TQueryServiceConfigA = _QUERY_SERVICE_CONFIGA;
  316.   TQueryServiceConfigW = _QUERY_SERVICE_CONFIGW;
  317.   TQueryServiceConfig = TQueryServiceConfigA;
  318.  
  319. //
  320. // Function Prototype for the Service Main Function
  321. //
  322.  
  323. {$IFDEF STRICT}
  324.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONA}
  325.   LPSERVICE_MAIN_FUNCTIONA = procedure (dwNumServicesArgs: DWORD;
  326.     lpServiceArgVectors: PLPSTRA) stdcall;
  327.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONW}
  328.   LPSERVICE_MAIN_FUNCTIONW = procedure (dwNumServicesArgs: DWORD;
  329.     lpServiceArgVectors: PLPSTRW) stdcall;
  330.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
  331.   LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA;
  332. {$ELSE}
  333.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONA}
  334.   LPSERVICE_MAIN_FUNCTIONA = TFarProc;
  335.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONW}
  336.   LPSERVICE_MAIN_FUNCTIONW = TFarProc;
  337.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
  338.   LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA;
  339. {$ENDIF}
  340.   TServiceMainFunctionA = LPSERVICE_MAIN_FUNCTIONA;
  341.   TServiceMainFunctionW = LPSERVICE_MAIN_FUNCTIONW;
  342.   TServiceMainFunction = TServiceMainFunctionA;
  343.  
  344. //
  345. // Service Start Table
  346. //
  347.   PServiceTableEntryA = ^TServiceTableEntryA;
  348.   PServiceTableEntryW = ^TServiceTableEntryW;
  349.   PServiceTableEntry = PServiceTableEntryA;
  350.   {$EXTERNALSYM _SERVICE_TABLE_ENTRYA}
  351.   _SERVICE_TABLE_ENTRYA = record
  352.     lpServiceName: PAnsiChar;
  353.     lpServiceProc: TServiceMainFunctionA;
  354.   end;
  355.   {$EXTERNALSYM _SERVICE_TABLE_ENTRYW}
  356.   _SERVICE_TABLE_ENTRYW = record
  357.     lpServiceName: PWideChar;
  358.     lpServiceProc: TServiceMainFunctionW;
  359.   end;
  360.   {$EXTERNALSYM _SERVICE_TABLE_ENTRY}
  361.   _SERVICE_TABLE_ENTRY = _SERVICE_TABLE_ENTRYA;
  362.   {$EXTERNALSYM SERVICE_TABLE_ENTRYA}
  363.   SERVICE_TABLE_ENTRYA = _SERVICE_TABLE_ENTRYA;
  364.   {$EXTERNALSYM SERVICE_TABLE_ENTRYW}
  365.   SERVICE_TABLE_ENTRYW = _SERVICE_TABLE_ENTRYW;
  366.   {$EXTERNALSYM SERVICE_TABLE_ENTRY}
  367.   SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYA;
  368.   TServiceTableEntryA = _SERVICE_TABLE_ENTRYA;
  369.   TServiceTableEntryW = _SERVICE_TABLE_ENTRYW;
  370.   TServiceTableEntry = TServiceTableEntryA;
  371.  
  372. //
  373. // Prototype for the Service Control Handler Function
  374. //
  375.  
  376. {$IFDEF STRICT}
  377.   {$EXTERNALSYM LPHANDLER_FUNCTION}
  378.   LPHANDLER_FUNCTION = procedure (dwControl: DWORD) stdcall;
  379. {$ELSE}
  380.   {$EXTERNALSYM LPHANDLER_FUNCTION}
  381.   LPHANDLER_FUNCTION = TFarProc;
  382. {$ENDIF}
  383.   THandlerFunction = LPHANDLER_FUNCTION;
  384.  
  385. ///////////////////////////////////////////////////////////////////////////
  386. // API Function Prototypes
  387. ///////////////////////////////////////////////////////////////////////////
  388.  
  389. {$EXTERNALSYM ChangeServiceConfigA}
  390. function ChangeServiceConfigA(hService: SC_HANDLE; dwServiceType, dwStartType,
  391.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: PAnsiChar;
  392.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  393.   lpDisplayName: PAnsiChar): BOOL; stdcall;
  394. {$EXTERNALSYM ChangeServiceConfigW}
  395. function ChangeServiceConfigW(hService: SC_HANDLE; dwServiceType, dwStartType,
  396.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: PWideChar;
  397.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  398.   lpDisplayName: PWideChar): BOOL; stdcall;
  399. {$EXTERNALSYM ChangeServiceConfig}
  400. function ChangeServiceConfig(hService: SC_HANDLE; dwServiceType, dwStartType,
  401.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: PChar;
  402.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  403.   lpDisplayName: PChar): BOOL; stdcall;
  404. {$EXTERNALSYM CloseServiceHandle}
  405. function CloseServiceHandle(hSCObject: SC_HANDLE): BOOL; stdcall;
  406. {$EXTERNALSYM ControlService}
  407. function ControlService(hService: SC_HANDLE; dwControl: DWORD;
  408.   var lpServiceStatus: TServiceStatus): BOOL; stdcall;
  409. {$EXTERNALSYM CreateServiceA}
  410. function CreateServiceA(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: PAnsiChar;
  411.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  412.   lpBinaryPathName, lpLoadOrderGroup: PAnsiChar; lpdwTagId: LPDWORD; lpDependencies,
  413.   lpServiceStartName, lpPassword: PAnsiChar): SC_HANDLE; stdcall;
  414. {$EXTERNALSYM CreateServiceW}
  415. function CreateServiceW(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: PWideChar;
  416.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  417.   lpBinaryPathName, lpLoadOrderGroup: PWideChar; lpdwTagId: LPDWORD; lpDependencies,
  418.   lpServiceStartName, lpPassword: PWideChar): SC_HANDLE; stdcall;
  419. {$EXTERNALSYM CreateService}
  420. function CreateService(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: PChar;
  421.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  422.   lpBinaryPathName, lpLoadOrderGroup: PChar; lpdwTagId: LPDWORD; lpDependencies,
  423.   lpServiceStartName, lpPassword: PChar): SC_HANDLE; stdcall;
  424. {$EXTERNALSYM DeleteService}
  425. function DeleteService(hService: SC_HANDLE): BOOL; stdcall;
  426. {$EXTERNALSYM EnumDependentServicesA}
  427. function EnumDependentServicesA(hService: SC_HANDLE; dwServiceState: DWORD;
  428.   var lpServices: TEnumServiceStatusA; cbBufSize: DWORD; var pcbBytesNeeded,
  429.   lpServicesReturned : DWORD): BOOL; stdcall;
  430. {$EXTERNALSYM EnumDependentServicesW}
  431. function EnumDependentServicesW(hService: SC_HANDLE; dwServiceState: DWORD;
  432.   var lpServices: TEnumServiceStatusW; cbBufSize: DWORD; var pcbBytesNeeded,
  433.   lpServicesReturned : DWORD): BOOL; stdcall;
  434. {$EXTERNALSYM EnumDependentServices}
  435. function EnumDependentServices(hService: SC_HANDLE; dwServiceState: DWORD;
  436.   var lpServices: TEnumServiceStatus; cbBufSize: DWORD; var pcbBytesNeeded,
  437.   lpServicesReturned : DWORD): BOOL; stdcall;
  438. {$EXTERNALSYM EnumServicesStatusA}
  439. function EnumServicesStatusA(hSCManager: SC_HANDLE; dwServiceType,
  440.   dwServiceState: DWORD; var lpServices: TEnumServiceStatusA; cbBufSize: DWORD;
  441.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  442. {$EXTERNALSYM EnumServicesStatusW}
  443. function EnumServicesStatusW(hSCManager: SC_HANDLE; dwServiceType,
  444.   dwServiceState: DWORD; var lpServices: TEnumServiceStatusW; cbBufSize: DWORD;
  445.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  446. {$EXTERNALSYM EnumServicesStatus}
  447. function EnumServicesStatus(hSCManager: SC_HANDLE; dwServiceType,
  448.   dwServiceState: DWORD; var lpServices: TEnumServiceStatus; cbBufSize: DWORD;
  449.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  450. {$EXTERNALSYM GetServiceKeyNameA}
  451. function GetServiceKeyNameA(hSCManager: SC_HANDLE; lpDisplayName,
  452.   lpServiceName: PAnsiChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  453. {$EXTERNALSYM GetServiceKeyNameW}
  454. function GetServiceKeyNameW(hSCManager: SC_HANDLE; lpDisplayName,
  455.   lpServiceName: PWideChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  456. {$EXTERNALSYM GetServiceKeyName}
  457. function GetServiceKeyName(hSCManager: SC_HANDLE; lpDisplayName,
  458.   lpServiceName: PChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  459. {$EXTERNALSYM GetServiceDisplayNameA}
  460. function GetServiceDisplayNameA(hSCManager: SC_HANDLE; lpServiceName,
  461.   lpDisplayName: PAnsiChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  462. {$EXTERNALSYM GetServiceDisplayNameW}
  463. function GetServiceDisplayNameW(hSCManager: SC_HANDLE; lpServiceName,
  464.   lpDisplayName: PWideChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  465. {$EXTERNALSYM GetServiceDisplayName}
  466. function GetServiceDisplayName(hSCManager: SC_HANDLE; lpServiceName,
  467.   lpDisplayName: PChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  468. {$EXTERNALSYM LockServiceDatabase}
  469. function LockServiceDatabase(hSCManager: SC_HANDLE): SC_LOCK; stdcall;
  470. {$EXTERNALSYM NotifyBootConfigStatus}
  471. function NotifyBootConfigStatus(BootAcceptable: BOOL): BOOL; stdcall;
  472. {$EXTERNALSYM OpenSCManagerA}
  473. function OpenSCManagerA(lpMachineName, lpDatabaseName: PAnsiChar;
  474.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  475. {$EXTERNALSYM OpenSCManagerW}
  476. function OpenSCManagerW(lpMachineName, lpDatabaseName: PWideChar;
  477.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  478. {$EXTERNALSYM OpenSCManager}
  479. function OpenSCManager(lpMachineName, lpDatabaseName: PChar;
  480.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  481. {$EXTERNALSYM OpenServiceA}
  482. function OpenServiceA(hSCManager: SC_HANDLE; lpServiceName: PAnsiChar;
  483.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  484. {$EXTERNALSYM OpenServiceW}
  485. function OpenServiceW(hSCManager: SC_HANDLE; lpServiceName: PWideChar;
  486.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  487. {$EXTERNALSYM OpenService}
  488. function OpenService(hSCManager: SC_HANDLE; lpServiceName: PChar;
  489.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  490. {$EXTERNALSYM QueryServiceConfigA}
  491. function QueryServiceConfigA(hService: SC_HANDLE;
  492.   var lpServiceConfig: TQueryServiceConfigA; cbBufSize: DWORD;
  493.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  494. {$EXTERNALSYM QueryServiceConfigW}
  495. function QueryServiceConfigW(hService: SC_HANDLE;
  496.   var lpServiceConfig: TQueryServiceConfigW; cbBufSize: DWORD;
  497.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  498. {$EXTERNALSYM QueryServiceConfig}
  499. function QueryServiceConfig(hService: SC_HANDLE;
  500.   var lpServiceConfig: TQueryServiceConfig; cbBufSize: DWORD;
  501.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  502. {$EXTERNALSYM QueryServiceLockStatusA}
  503. function QueryServiceLockStatusA(hSCManager: SC_HANDLE;
  504.   var lpLockStatus: TQueryServiceLockStatusA; cbBufSize: DWORD;
  505.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  506. {$EXTERNALSYM QueryServiceLockStatusW}
  507. function QueryServiceLockStatusW(hSCManager: SC_HANDLE;
  508.   var lpLockStatus: TQueryServiceLockStatusW; cbBufSize: DWORD;
  509.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  510. {$EXTERNALSYM QueryServiceLockStatus}
  511. function QueryServiceLockStatus(hSCManager: SC_HANDLE;
  512.   var lpLockStatus: TQueryServiceLockStatus; cbBufSize: DWORD;
  513.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  514. {$EXTERNALSYM QueryServiceObjectSecurity}
  515. function QueryServiceObjectSecurity(hService: SC_HANDLE;
  516.   dwSecurityInformation: SECURITY_INFORMATION;
  517.   lpSecurityDescriptor: PSECURITY_DESCRIPTOR; cbBufSize: DWORD;
  518.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  519. {$EXTERNALSYM QueryServiceStatus}
  520. function QueryServiceStatus(hService: SC_HANDLE; var
  521.   lpServiceStatus: TServiceStatus): BOOL; stdcall;
  522. {$EXTERNALSYM RegisterServiceCtrlHandlerA}
  523. function RegisterServiceCtrlHandlerA(lpServiceName: PAnsiChar;
  524.   lpHandlerProc: ThandlerFunction): SERVICE_STATUS_HANDLE; stdcall;
  525. {$EXTERNALSYM RegisterServiceCtrlHandlerW}
  526. function RegisterServiceCtrlHandlerW(lpServiceName: PWideChar;
  527.   lpHandlerProc: ThandlerFunction): SERVICE_STATUS_HANDLE; stdcall;
  528. {$EXTERNALSYM RegisterServiceCtrlHandler}
  529. function RegisterServiceCtrlHandler(lpServiceName: PChar;
  530.   lpHandlerProc: ThandlerFunction): SERVICE_STATUS_HANDLE; stdcall;
  531. {$EXTERNALSYM SetServiceObjectSecurity}
  532. function SetServiceObjectSecurity(hService: SC_HANDLE;
  533.   dwSecurityInformation: SECURITY_INFORMATION;
  534.   lpSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
  535. {$EXTERNALSYM SetServiceStatus}
  536. function SetServiceStatus(hServiceStatus: SERVICE_STATUS_HANDLE;
  537.   var lpServiceStatus: TServiceStatus): BOOL; stdcall;
  538. {$EXTERNALSYM StartServiceCtrlDispatcherA}
  539. function StartServiceCtrlDispatcherA(
  540.   var lpServiceStartTable: TServiceTableEntryA): BOOL; stdcall;
  541. {$EXTERNALSYM StartServiceCtrlDispatcherW}
  542. function StartServiceCtrlDispatcherW(
  543.   var lpServiceStartTable: TServiceTableEntryW): BOOL; stdcall;
  544. {$EXTERNALSYM StartServiceCtrlDispatcher}
  545. function StartServiceCtrlDispatcher(
  546.   var lpServiceStartTable: TServiceTableEntry): BOOL; stdcall;
  547. {$EXTERNALSYM StartServiceA}
  548. function StartServiceA(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  549.   var lpServiceArgVectors: PAnsiChar): BOOL; stdcall;
  550. {$EXTERNALSYM StartServiceW}
  551. function StartServiceW(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  552.   var lpServiceArgVectors: PWideChar): BOOL; stdcall;
  553. {$EXTERNALSYM StartService}
  554. function StartService(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  555.   var lpServiceArgVectors: PChar): BOOL; stdcall;
  556. {$EXTERNALSYM UnlockServiceDatabase}
  557. function UnlockServiceDatabase(ScLock: SC_LOCK): BOOL; stdcall;
  558.  
  559. implementation
  560.  
  561. const
  562.   advapi32 = 'advapi32.dll';
  563.  
  564. function ChangeServiceConfigA;   external advapi32 name 'ChangeServiceConfigA';
  565. function ChangeServiceConfigW;   external advapi32 name 'ChangeServiceConfigW';
  566. function ChangeServiceConfig;   external advapi32 name 'ChangeServiceConfigA';
  567. function CloseServiceHandle;       external advapi32 name 'CloseServiceHandle';
  568. function ControlService;           external advapi32 name 'ControlService';
  569. function CreateServiceA;         external advapi32 name 'CreateServiceA';
  570. function CreateServiceW;         external advapi32 name 'CreateServiceW';
  571. function CreateService;         external advapi32 name 'CreateServiceA';
  572. function DeleteService;            external advapi32 name 'DeleteService';
  573. function EnumDependentServicesA; external advapi32 name 'EnumDependentServicesA';
  574. function EnumDependentServicesW; external advapi32 name 'EnumDependentServicesW';
  575. function EnumDependentServices; external advapi32 name 'EnumDependentServicesA';
  576. function EnumServicesStatusA;    external advapi32 name 'EnumServicesStatusA';
  577. function EnumServicesStatusW;    external advapi32 name 'EnumServicesStatusW';
  578. function EnumServicesStatus;    external advapi32 name 'EnumServicesStatusA';
  579. function GetServiceKeyNameA;     external advapi32 name 'GetServiceKeyNameA';
  580. function GetServiceKeyNameW;     external advapi32 name 'GetServiceKeyNameW';
  581. function GetServiceKeyName;     external advapi32 name 'GetServiceKeyNameA';
  582. function GetServiceDisplayNameA; external advapi32 name 'GetServiceDisplayNameA';
  583. function GetServiceDisplayNameW; external advapi32 name 'GetServiceDisplayNameW';
  584. function GetServiceDisplayName; external advapi32 name 'GetServiceDisplayNameA';
  585. function LockServiceDatabase;      external advapi32 name 'LockServiceDatabase';
  586. function NotifyBootConfigStatus;   external advapi32 name 'NotifyBootConfigStatus';
  587. function OpenSCManagerA;         external advapi32 name 'OpenSCManagerA';
  588. function OpenSCManagerW;         external advapi32 name 'OpenSCManagerW';
  589. function OpenSCManager;         external advapi32 name 'OpenSCManagerA';
  590. function OpenServiceA;           external advapi32 name 'OpenServiceA';
  591. function OpenServiceW;           external advapi32 name 'OpenServiceW';
  592. function OpenService;           external advapi32 name 'OpenServiceA';
  593. function QueryServiceConfigA;    external advapi32 name 'QueryServiceConfigA';
  594. function QueryServiceConfigW;    external advapi32 name 'QueryServiceConfigW';
  595. function QueryServiceConfig;    external advapi32 name 'QueryServiceConfigA';
  596. function QueryServiceLockStatusA;external advapi32 name 'QueryServiceLockStatusA';
  597. function QueryServiceLockStatusW;external advapi32 name 'QueryServiceLockStatusW';
  598. function QueryServiceLockStatus;external advapi32 name 'QueryServiceLockStatusA';
  599. function QueryServiceObjectSecurity;external advapi32 name 'QueryServiceObjectSecurity';
  600. function QueryServiceStatus;       external advapi32 name 'QueryServiceStatus';
  601. function RegisterServiceCtrlHandlerA;external advapi32 name 'RegisterServiceCtrlHandlerA';
  602. function RegisterServiceCtrlHandlerW;external advapi32 name 'RegisterServiceCtrlHandlerW';
  603. function RegisterServiceCtrlHandler;external advapi32 name 'RegisterServiceCtrlHandlerA';
  604. function SetServiceObjectSecurity; external advapi32 name 'SetServiceObjectSecurity';
  605. function SetServiceStatus;         external advapi32 name 'SetServiceStatus';
  606. function StartServiceCtrlDispatcherA;external advapi32 name 'StartServiceCtrlDispatcherA';
  607. function StartServiceCtrlDispatcherW;external advapi32 name 'StartServiceCtrlDispatcherW';
  608. function StartServiceCtrlDispatcher;external advapi32 name 'StartServiceCtrlDispatcherA';
  609. function StartServiceA;          external advapi32 name 'StartServiceA';
  610. function StartServiceW;          external advapi32 name 'StartServiceW';
  611. function StartService;          external advapi32 name 'StartServiceA';
  612. function UnlockServiceDatabase;    external advapi32 name 'UnlockServiceDatabase';
  613.  
  614. end.
  615.  
  616.